#include <iostream>
#include <fstream>
#include <vector>
#include <sys/time.h>

using namespace std;

//#define ONLINE_JUDGE
#define NO_DEBUG

class Encuesta {
public:
	Encuesta (int i) {
		vector<int> p1(i,0);
		M_confianza = new vector< vector<int> >(i, p1);
		M_desconfianza = new vector< vector<int> >(i, p1);
		this->n = i;
	};
	
	~Encuesta()	{
		delete M_confianza;
		delete M_desconfianza;
	};
	
	void opinar(int x, int y){
		if (y>0)
			(*M_confianza)[x-1][y-1] = 1;
		else
			(*M_desconfianza)[x-1][-y-1] = -1;
	};

	bool confia(int x, int y) const { return (*M_confianza)[x-1][y-1] == 1; } ;
	bool desconfia(int x, int y) const { return (*M_desconfianza)[x-1][y-1] == -1; } ;
	
	int numAgentes() const {
		return this->n;
	}
	
	private:
		// Matriz de confianza: 
		// x SÍ confía en y -->  M(x,y) =  1
		// x NO confía en y -->  M(x,y) = -1
		// sino M(x,y) = 0
	
		vector< vector<int> >* M_confianza;
		vector< vector<int> >* M_desconfianza;
		int n;
		
};

class Conjunto {
public:	
	Conjunto (int i) {
		this->S = new int[i];
		for (int j=0; j<i; j++)
			this->S[j]=0;		
		this->size = 0;
		n = i;
	};
	
	~Conjunto() {
		delete [] S;
	};

	int tamanio() {
		return this->size;
	};

	bool esta(int i) {
		return this->S[i-1];
	};
	
	void agregar(int i) {
		if (!esta(i)) {
			this->S[i-1] = 1;
			this->size++;
		}
	};
	
	void quitar(int i) {
		if (esta(i)) {		
			this->S[i-1] = 0;
			this->size--;
		}
	};
		
	void listar() {
		for (int i = 1; i<=n; i++)
			if (esta(i)) cout << "  " << i;
		cout << endl;
		};
	
	private:
		int* S;
		int size;	int n;
};


bool noPrometedor(int k, Conjunto &S, const Encuesta &E) {
	// Si por alguna de las siguientes razones no puedo agregar k
	// 1. desconfia de si mismo ...
	// 2. alguien de S no confia en k
	// 3. k no confia en alguien de S
	// 4. k confia en alguien que no fue agregado en S	(y por si acaso no verificamos que confie en si mismo)
	// 5. k confia en alguien del cual alguien de S desconfia
	// 6. k no confia en alguien en quien alguien S confia
	
	
	bool K_noConfiaS, S_noConfiaK, K_ConfiaYNoEsta, noEstaAgente, EstaAgente;
	bool motivoParaNoAgregar;
	
	// 1. desconfia de si mismo ...
	if (E.desconfia(k,k))
		return true;
	
	
	
	for (int i = 1; i < k; i++) {
		EstaAgente = S.esta(i);
		noEstaAgente = !EstaAgente;
		
		// 2. alguien de S no confia en k
		S_noConfiaK = EstaAgente && E.desconfia(i,k);
		
		// 3. k no confia en alguien de S
		K_noConfiaS = EstaAgente && E.desconfia(k,i);
		
		// 4. k confia en alguien que no fue agregado en S
		K_ConfiaYNoEsta = noEstaAgente && E.confia(k,i);
		
		
		motivoParaNoAgregar = S_noConfiaK || K_noConfiaS;
		
		motivoParaNoAgregar = motivoParaNoAgregar || K_ConfiaYNoEsta;
		
		if (motivoParaNoAgregar)
			return true;
	}
	
	return false;
}



bool prometedor(int k, Conjunto &S, const Encuesta &E) {
	// ¿Algun agente de S confia en k? 
	for (int i = 1; i<k ; i++) {
		if (S.esta(i) && E.confia(i,k))
			return true;
	}

	return false;
}


void intentar (Conjunto &S, const Encuesta &E, int &max, int i) {
	int k = i+1;
	
	if (i >= E.numAgentes()) {
		if (S.tamanio() >= max) {
#ifndef NO_DEBUG
			S.listar();
			cout << "TAM = " << S.tamanio() << endl;
#endif
			max = S.tamanio();
		}
		return;
	}
	
	//Si alguien confia en k pero k es no prometedor, entonces la solución que estamos armando no es posible :S
	bool esPrometedor = prometedor(k,S,E), noEsPrometedor = noPrometedor(k,S,E);
	
	if(esPrometedor && noEsPrometedor)
		return;
	
	else if (noEsPrometedor){
		S.quitar(k);
		intentar(S,E,max,k);
	}
	
	else if (esPrometedor) {
			S.agregar(k);
			intentar(S,E,max,k);
	}
	
	else {	
		//intento sin k en S (rama 0)
		S.quitar(k);
		intentar(S,E,max,k);
		
		
		//intento con k en S (rama 1)
		S.agregar(k);
		intentar(S,E,max,k);
	}
	
}

int resolver( Conjunto &S, const Encuesta &E ) {
	int t_max = 0;
	
	intentar(S, E, t_max, 0);
	
	return t_max;
}

void resolverDesdeEntrada( istream &entrada, ostream &salida ) {
	int i, a;
	
	while ( entrada.good() ) {
		entrada >> i >> a;

		if ( !entrada.good() || (i==0 && a==0))
				break;

		Encuesta E(i);
		Conjunto S(i);
		
		for ( int c = 0; c < a; c++ ) {
			int x, y;
			entrada >> x >> y;
			
			E.opinar(x,y);
		}
		
		salida << resolver( S, E ) << endl;
	}
}

#ifdef ONLINE_JUDGE
int main() {
	resolverDesdeEntrada( cin, cout );
	return 0;
}
#endif